package demo.dubbo.config;

import java.util.Arrays;
import java.util.HashMap;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.alibaba.dubbo.config.ApplicationConfig;
import com.alibaba.dubbo.config.ArgumentConfig;
import com.alibaba.dubbo.config.ConsumerConfig;
import com.alibaba.dubbo.config.MethodConfig;
import com.alibaba.dubbo.config.ModuleConfig;
import com.alibaba.dubbo.config.MonitorConfig;
import com.alibaba.dubbo.config.ProtocolConfig;
import com.alibaba.dubbo.config.ProviderConfig;
import com.alibaba.dubbo.config.ReferenceConfig;
import com.alibaba.dubbo.config.RegistryConfig;
import com.alibaba.dubbo.config.ServiceConfig;
import com.alibaba.dubbo.registry.RegistryFactory;
import com.alibaba.dubbo.rpc.service.GenericService;

import demo.design.patterns.structural.FacadeDemo;
import demo.dubbo.provider.service.FacadeDemoService;

/**
 * 
 * @author hanjy
 *
 */
public class ConfigDemo {

    private static Logger logger = LoggerFactory.getLogger(ConfigDemo.class);

    public static void main(String[] args) {
        GenericService a = null;

        RegistryFactory b = null;
    }

    /**
     * 模块配置 :用于配置当前模块信息，可选
     */
    public void moduleConfig() {
        ModuleConfig cfg = new ModuleConfig();
        // 服务治理 # 当前模块名称，用于注册中心计算模块间依赖关系
        cfg.setName("name");
        // 服务治理 # 当前模块的版本
        cfg.setVersion("V1.10");
        // 服务治理 # 模块负责人，用于服务治理，请填写负责人公司邮箱前缀
        cfg.setOwner("junyinghan");
        // 服务治理 # 组织名称(BU或部门)，用于注册中心区分服务来源，此配置项建议不要使用autoconfig，直接写死在配置中，比如china,intl,itu,crm,asc,dw,aliexpress等
        cfg.setOrganization("风控部门");

    }

    /**
     * 引用配置: 用于创建一个远程服务代理，一个引用可以指向多个注册中心
     */
    public void referenceConfig() {
        ReferenceConfig cfg = new ReferenceConfig<>();
        //   配置关联 # 服务引用Bean Id 即为注入名
        cfg.setId("beanId");
        //     服务发现# 服务接口名
        cfg.setInterface(FacadeDemo.class);
        //   服务发现 # 服务版本，与服务提供者的版本一致
        cfg.setVersion("1.0");
        // 服务发现 # 服务分组，当一个接口有多个实现，可以用分组区分，必需和服务提供方一致
        cfg.setGroup("group1");
        // 缺省使用<dubbo:consumer>的timeout 。 性能调优 #服务方法调用超时时间(毫秒)
        cfg.setTimeout(5 * 1000);
        // 缺省使用<dubbo:consumer>的retries 。 性能调优 #远程服务调用重试次数，不包括第一次调用，不需要重试请设为0
        cfg.setRetries(2);
        // 缺省使用<dubbo:consumer>的connections 。 性能调优# 对每个提供者的最大连接数，rmi、http、hessian等短连接协议表示限制连接数，dubbo等长连接协表示建立的长连接个数
        cfg.setConnections(1);
        // 缺省使用<dubbo:consumer>的loadbalance 。 性能调优 # 负载均衡策略，可选值：random,roundrobin,leastactive，分别表示：随机，轮循，最少活跃调用
        cfg.setLoadbalance("random");
        // 缺省使用<dubbo:consumer>的async 。性能调优 #是否异步执行，不可靠异步，只是忽略返回值，不阻塞执行线程
        cfg.setAsync(false);
        // 缺省使用<dubbo:consumer>的generic 。 服务治理 # 是否缺省泛化接口，如果为泛化接口，将返回GenericService
        cfg.setGeneric(false);
        // 缺省使用<dubbo:consumer>的check 。服务治理 # 启动时检查提供者是否存在，true报错，false忽略
        cfg.setCheck(false);
        // 服务治理 #点对点直连服务提供者地址，将绕过注册中心
        cfg.setUrl(null);
        /*
         * 服务治理 #服务接口客户端本地代理类名，用于在客户端执行本地逻辑，如本地缓存等，该本地代理类的构造函数必须允许传入远程代理对象，构造函数如： public XxxServiceLocal(XxxService
         * xxxService)
         */
        cfg.setStub(false);
        /*
         * 服务治理 #
         * 服务接口调用失败Mock实现类名，该Mock类必须有一个无参构造函数，与Local的区别在于，Local总是被执行，而Mock只在出现非业务异常(比如超时，网络异常等)时执行，Local在远程调用之前执行，
         * Mock在远程调用后执行。
         */
        cfg.setMock(false);
        // 服务治理 # 以调用参数为key，缓存返回结果，可选：lru, threadlocal, jcache等
        cfg.setCache(null);
        // 服务治理 # 是否启用JSR303标准注解验证，如果启用，将对方法参数上的注解进行校验
        cfg.setValidation(null);
        // 性能调优 # 选择动态代理实现策略，可选：javassist, jdk
        cfg.setProxy("javassist");
        // 性能调优 # 客户端传输类型设置，如Dubbo协议的netty或mina。
        cfg.setClient("netty");
        //   缺省将从所有注册中心获服务列表后合并结果 。 配置关联# 从指定注册中心注册获取服务列表，在多个注册中心时使用，值为<dubbo:registry>的id属性，多个注册中心ID用逗号分隔
        cfg.setRegistry(null);
        // 服务治理 # 调用服务负责人，用于服务治理，请填写负责人公司邮箱前缀
        cfg.setOwner("junyinghan@126.com");
        // 性能调优 # 每服务消费者每服务每方法最大并发调用数
        cfg.setActives(0);
        // 性能调优 # 集群方式，可选：failover/failfast/failsafe/failback/forking
        cfg.setCluster("failover");
        // 性能调优 # 服务消费方远程调用过程拦截器名称，多个名称用逗号分隔
        cfg.setFilter(null);
        // 性能调优 #服务消费方引用服务监听器名称，多个名称用逗号分隔
        cfg.setListener(null);
        // 服务治理 # 服务调用者所在的分层。如：biz、dao、intl:web、china:acton。
        cfg.setLayer("dao");
        // 性能调优 #是否在afterPropertiesSet()时饥饿初始化引用，否则等到有人注入或引用该实例时再初始化。
        cfg.setInit(false);
        //   服力治理 #只调用指定协议的服务提供方，其它协议忽略。
        cfg.setProtocol(null);

    }

    /**
     * 服务消费者缺省值配置。同时该标签为 <dubbo:reference> 标签的缺省值设置。 消费方配置 :当 ReferenceConfig 某属性没有配置时，采用此缺省值，可选
     */
    public void consumerConfig() {
        ConsumerConfig cfg = new ConsumerConfig();
        // 性能调优: 远程服务调用超时时间(毫秒)
        cfg.setTimeout(1000);
        // 性能调优: 远程服务调用重试次数，不包括第一次调用，不需要重试请设为0
        cfg.setRetries(2);
        // 性能调优: 负载均衡策略，可选值：random,roundrobin,leastactive，分别表示：随机，轮循，最少活跃调用
        cfg.setLoadbalance("random");
        // 性能调优: 是否缺省异步执行，不可靠异步，只是忽略返回值，不阻塞执行线程
        cfg.setAsync(false);
        // 性能调优: 每个服务对每个提供者的最大连接数，rmi、http、hessian等短连接协议支持此配置，dubbo协议长连接不支持此配置
        cfg.setConnections(100);
        // 服务治理 : 是否缺省泛化接口，如果为泛化接口，将返回GenericService
        cfg.setGeneric(false);
        // 服务治理: 启动时检查提供者是否存在，true报错，false忽略 。Dubbo 缺省会在启动时检查依赖的服务是否可用，不可用时会抛出异常，阻止 Spring 初始化完成，以便上线时，能及早发现问题
        cfg.setCheck(true);
        // 性能调优: 生成动态代理方式，可选：jdk/javassist
        cfg.setProxy("javassist");
        // 服务治理: 调用服务负责人，用于服务治理，请填写负责人公司邮箱前缀
        cfg.setOwner("hanjy@2345.com");
        // 性能调优: 每服务消费者每服务每方法最大并发调用数
        cfg.setActives(0);
        // 性能调优 : 集群方式，可选：failover/failfast/failsafe/failback/forking
        cfg.setCluster("failover");
        // 性能调优: 服务消费方远程调用过程拦截器名称，多个名称用逗号分隔
        cfg.setFilter("a,b");
        // 性能调优 : 服务消费方引用服务监听器名称，多个名称用逗号分隔
        cfg.setListener("a,b");
        /*
         * 缺省向所有registry注册, 配置关联:
         * 向指定注册中心注册，在多个注册中心时使用，值为<dubbo:registry>的id属性，多个注册中心ID用逗号分隔，如果不想将该服务注册到任何registry，可将值设为N/A
         */
        cfg.setRegistry(null);
        // 服务治理: 服务调用者所在的分层。如：biz、dao、intl:web、china:acton
        cfg.setLayer("dao");
        // 性能调优: 是否在afterPropertiesSet()时饥饿初始化引用，否则等到有人注入或引用该实例时再初始化。
        cfg.setInit(false);
        // 服务治理: 以调用参数为key，缓存返回结果，可选：lru, threadlocal, jcache等
        cfg.setCache("lru");
        // 服务治理: 是否启用JSR303标准注解验证，如果启用，将对方法参数上的
        cfg.setValidation("");
    }

    /**
     * 监控中心配置 : 用于配置连接监控中心相关信息，可选
     */
    public void monitorConfig() {
        MonitorConfig cfg = new MonitorConfig();
        // 服务治理 # 监控中心协议，如果为protocol="registry"，表示从注册中心发现监控中心地址，否则直连监控中心。
        cfg.setProtocol("dubbo");
        // 服务治理 # 直连监控中心服务器地址，address="10.20.130.230:12080"
        cfg.setAddress("N/A");
    }

    /**
     * 注册中心配置: 用于配置连接注册中心相关信息。 同时如果有多个不同的注册中心，可以声明多个 <dubbo:registry> 标签， 并在 <dubbo:service> 或 <dubbo:reference> 的
     * registry 属性指定使用的注册中心。
     */
    public void registryConfig() {
        RegistryConfig cfg = new RegistryConfig();
        //   配置关联# 注册中心引用BeanId，可以在<dubbo:service registry="">或<dubbo:reference registry="">中引用此ID
        cfg.setId("beanId");
        /* 服务发现# 注册中心服务器地址，如果地址没有端口缺省为9090，同一集群内的多个地址用逗号分隔，如：ip:port,ip:port，不同集群的注册中心，请配置多个<dubbo:registry>标签 */
        cfg.setAddress("localhost:2181");
        // 服务发现 #注同中心地址协议，支持dubbo, http, local三种协议，分别表示，dubbo地址，http地址，本地注册中心
        cfg.setProtocol("dubbo");
        // 服务发现 #注册中心缺省端口，当address没有带端口时使用此端口做为缺省值
        cfg.setPort(9090);
        // 服务治理 # 登录注册中心用户名，如果注册中心不需要验证可不填
        cfg.setUsername("userStan");
        // 服务治理 # 登录注册中心密码，如果注册中心不需要验证可不填
        cfg.setPassword("password");
        // 性能调优 # 网络传输方式，可选mina,netty
        cfg.setTransporter("netty");
        // 性能调优 # 注册中心请求超时时间(毫秒)
        cfg.setTimeout(5000);
        // 性能调优 # 注册中心会话超时时间(毫秒)，用于检测提供者非正常断线后的脏数据，比如用心跳检测的实现，此时间就是心跳间隔，不同注册中心实现不一样。
        cfg.setSession(60_000);
        // 服务治理 #使用文件缓存注册中心地址列表及服务提供者列表，应用重启时将基于此文件恢复，注意：两个注册中心不能使用同一文件存储
        cfg.setFile("a.txt");
        // 性能调优# 停止时等待通知完成时间(毫秒)
        cfg.setWait(0);
        // 服务治理# 注册中心不存在时，是否报错
        cfg.setCheck(true);
        // 服务治理# 是否向此注册中心注册服务，如果设为false，将只订阅，不注册
        cfg.setRegister(true);
        // 服务治理 # 是否向此注册中心订阅服务，如果设为false，将只注册，不订阅
        cfg.setSubscribe(true);
        // 服务治理 #服务是否动态注册，如果设为false，注册后将显示后disable状态，需人工启用，并且服务提供者停止时，也不会自动取消册，需人工禁用。
        cfg.setDynamic(true);

    }

    /**
     * 应用配置 :用于配置当前应用信息，不管该应用是提供者还是消费者
     */
    public void applicationConfig() {
        ApplicationConfig cfg = new ApplicationConfig();
        /*
         * 服务治理 # 当前应用名称，用于注册中心计算应用间依赖关系， 注意：消费者和提供者应用名不要一样，此参数不是匹配条件，你当前项目叫什么名字就填什么，和提供者消费者角色无关，
         * 比如：kylin应用调用了morgan应用的服务，则kylin项目配成kylin，morgan项目配成morgan，可能kylin也提供其它服务给别人使用，但kylin项目永远配成kylin，
         * 这样注册中心将显示kylin依赖于morgan
         */
        cfg.setName("name");
        // 服务治理 # 当前应用的版本
        cfg.setVersion("V1.1");
        // 服务治理 # 应用负责人，用于服务治理，请填写负责人公司邮箱前缀
        cfg.setOwner("junyinghan");
        // 服务治理 # 组织名称(BU或部门)，用于注册中心区分服务来源，此配置项建议不要使用autoconfig，直接写死在配置中，比如china,intl,itu,crm,asc,dw,aliexpress等
        cfg.setOrganization("aa");
        // 服务治理 # 用于服务分层对应的架构。如，intl、china。不同的架构使用不同的分层。
        cfg.setArchitecture("intl");
        // 服务治理 # 应用环境，如：develop/test/product，不同环境使用不同的缺省值，以及作为只用于开发测试功能的限制条件
        cfg.setEnvironment("product");
        // 性能优化 # Java字节码编译器，用于动态类的生成，可选：jdk或javassist
        cfg.setCompiler("javassist");
        // 性能优化 # 日志输出方式，可选：slf4j,jcl,log4j,jdk
        cfg.setLogger("slf4j");

    }

    /**
     * 方法配置: 用于 ServiceConfig 和 ReferenceConfig 指定方法级的配置信息。
     * 
     * <dubbo:method> 同时该标签为 <dubbo:service> 或 <dubbo:reference> 的子标签，用于控制到方法级。
     */
    public void methodConfig() {
        MethodConfig cfg = new MethodConfig();
        //   标识 # 方法名
        cfg.setName("methodName");
        // 性能调优 # 方法调用超时时间(毫秒)
        cfg.setTimeout(10 - 000);
        // 缺省为<dubbo:reference>的retries 。 性能调优 # 远程服务调用重试次数，不包括第一次调用，不需要重试请设为0
        cfg.setRetries(2);
        // 性能调优 # 负载均衡策略，可选值：random,roundrobin,leastactive，分别表示：随机，轮循，最少活跃调用
        cfg.setLoadbalance("random");
        // 缺省为<dubbo:reference>的async 性能调优 # 是否异步执行，不可靠异步，只是忽略返回值，不阻塞执行线程
        cfg.setAsync(false);
        // 性能调优 # 异步调用时，标记sent=true时，表示网络已发出数据
        cfg.setSent(true);
        // 性能调优 # 每服务消费者最大并发
        cfg.setActives(0);
        // 方法参数配置
        cfg.setArguments(Arrays.asList(argumentConfig()));
    }

    /**
     * 参数配置 :用于指定方法参数配置。 该标签为 <dubbo:method> 的子标签，用于方法参数的特征描述，比如：
     * 
     * <pre>
    <dubbo:method name="findXxx" timeout="3000" retries="2">
        <dubbo:argument index="0" callback="true" />
    </dubbo:method>
     * </pre>
     */
    static ArgumentConfig argumentConfig() {
        ArgumentConfig cfg = new ArgumentConfig();
        // 标识 # 方法名
        cfg.setIndex(0);
        // 与index二选一 。标识# 通过参数类型查找参数的index
        cfg.setType("");
        // 服务治理 #参数是否为callback接口，如果为callback，服务提供方将生成反向代理，可以从服务提供方反向调用消费方，通常用于事件推送.
        cfg.setCallback(true);
        return cfg;
    }

    /**
     * 提供方配置 : 当 ProtocolConfig 和 ServiceConfig 某属性没有配置时，采用此缺省值，可选
     * 
     * <pre>
     * dubbo://172.16.0.145:20076/com.loanking.feature.facade.DataUploadFacade
     * ?accepts=50
    &anyhost=true
    &application=feature-bone-provider
    &bind.ip=172.16.0.145
    &bind.port=20076
    &default.service.filter=dubboLogFilter,tracing
    &default.timeout=5000
    &dispatcher=all
    &dubbo=2.6.2
    &generic=false
    &interface=com.loanking.feature.facade.DataUploadFacade
    &logger=slf4j
    &methods=putDeviceData,putDeviceDataAsync,putMxData,bulkDeviceData
    &pid=9912
    &qos.enable=true
    &qos.port=21076
    &revision=1.4.0-SNAPSHOT
    &side=provider
    &threadpool=fixed
    &threads=200
    &timestamp=1551341071657
     * </pre>
     */
    public void providerConfig() {
        ProviderConfig cfg = new ProviderConfig();
        // 配置关联: 协议BeanId，可以在<dubbo:service proivder="">中引用此ID
        cfg.setId("beanId");
        // 是否导出服务
        cfg.setExport(true);
        // 性能调优 : 协议名称
        cfg.setProtocol(new ProtocolConfig("dubbo"));
        // 缺省自动查找本机IP ,服务发现 : 服务主机名，多网卡选择或指定VIP及域名时使用，为空则自动查找本机IP，建议不要配置，让Dubbo自动获取本机IP
        cfg.setHost(null);
        // 性能调优 ：服务线程池大小(固定大小)
        cfg.setThreads(100);
        // 性能调优： 请求及响应数据包大小限制，单位：字节
        cfg.setPayload(8 * 1024 * 1024);
        // 服务发现: 提供者上下文路径，为服务path的前缀
        cfg.setPath(null);
        // dubbo协议缺省为netty，http协议缺省为servlet , 性能调优: 协议的服务器端实现类型，比如：dubbo协议的mina,netty等，http协议的jetty,servlet等
        cfg.setServer("netty");
        // dubbo协议缺省为netty 性能调优: 协议的客户端实现类型，比如：dubbo协议的mina,netty等
        cfg.setClient("netty");
        // 性能调优 : 协议编码方式
        cfg.setCodec("dubbo");
        /*
         * dubbo协议缺省为hessian2，rmi协议缺省为java，http协议缺省为json , 性能调优 :
         * 协议序列化方式，当协议支持多种序列化方式时使用，比如：dubbo协议的dubbo,hessian2,java,compactedjava，以及http协议的json,xml等
         */
        cfg.setSerialization("hessian2");
        // 配置关联 :是否为缺省协议，用于多协议
        cfg.setDefault(false);
        // 性能调优# 服务提供方远程调用过程拦截器名称，多个名称用逗号分隔
        cfg.setFilter("");
        // 性能调优# 服务提供方导出服务监听器名称，多个名称用逗号分隔
        cfg.setListener("");
        // 性能调优# 线程池类型，可选：fixed/cached
        cfg.setThreadpool("fixed");
        // 性能调优 # 服务提供者最大可接受连接数
        cfg.setAccepts(0);
        // 服务发现 # 服务版本，建议使用两位数字版本，如：1.0，通常在接口不兼容时版本号才需要升级
        cfg.setVersion("1.2");
        // 服务发现 # 服务分组，当一个接口有多个实现，可以用分组区分
        cfg.setGroup("g1");
        // 性能调优 # 延迟注册服务时间(毫秒)- ，设为-1时，表示延迟到Spring容器初始化完成时暴露服务
        cfg.setDelay(-1);
        // 性能调优# 远程服务调用超时时间(毫秒)
        cfg.setTimeout(1000);
        // 性能调优 # 远程服务调用重试次数，不包括第一次调用，不需要重试请设为0
        cfg.setRetries(2);
        // 性能调优# 对每个提供者的最大连接数，rmi、http、hessian等短连接协议表示限制连接数，dubbo等长连接协表示建立的长连接个数
        cfg.setConnections(0);
        // 性能调优# 负载均衡策略，可选值：random,roundrobin,leastactive，分别表示：随机，轮循，最少活跃调用
        cfg.setLoadbalance("random");
        // 性能调优 # 是否缺省异步执行，不可靠异步，只是忽略返回值，不阻塞执行线程
        cfg.setAsync(false);
        // 服务治理 # 设为true，表示使用缺省代理类名，即：接口名 + Local后缀
        cfg.setStub(false);
        // 服务治理# 设为true，表示使用缺省Mock类名，即：接口名 + Mock后缀。
        cfg.setMock(false);
        // 服务治理 # 令牌验证，为空表示不开启，如果为true，表示随机生成动态令牌
        cfg.setToken(false);
        /*
         * 缺省向所有registry注册 。配置关联#
         * 向指定注册中心注册，在多个注册中心时使用，值为<dubbo:registry>的id属性，多个注册中心ID用逗号分隔，如果不想将该服务注册到任何registry，可将值设为N/A
         */
        cfg.setRegistry(null);
        // 服务治理# 服务是否动态注册，如果设为false，注册后将显示后disable状态，需人工启用，并且服务提供者停止时，也不会自动取消册，需人工禁用。
        cfg.setDynamic(true);
        // 服务治理 # 设为true，将向logger中输出访问日志，也可填写访问日志文件路径，直接把访问日志输出到指定文件
        cfg.setAccesslog(false);
        // 服务治理 #服务负责人，用于服务治理，请填写负责人公司邮箱前缀
        cfg.setOwner("hanjy@2345.com");
        // 服务治理 # 服务文档URL
        cfg.setDocument("");
        // 性能调优 # 服务权重
        cfg.setWeight(0);
        // 性能调优 # 服务提供者每服务每方法最大可并行执行请求数
        cfg.setExecutes(0);
        // 性能调优 # 每服务消费者每服务每方法最大并发调用数
        cfg.setActives(0);
        // 性能调优 # 生成动态代理方式，可选：jdk/javassist
        cfg.setProxy("javassist");
        // 性能调优 # 集群方式，可选：failover/failfast/failsafe/failback/forking
        cfg.setCluster("failover");
        // 服务治理 # 服务是否过时，如果设为true，消费方引用时将打印服务过时警告error日志
        cfg.setDeprecated(false);
        // 性能调优 # 线程池队列大小，当线程池满时，排队等待执行的队列大小，建议不要设置，当线程程池时应立即失败，重试其它服务提供机器，而不是排队，除非有特殊需求。
        cfg.setQueues(0);
        // 性能调优 # 序列化编码
        cfg.setCharset("UTF-8");
        // 性能调优# 网络读写缓冲区大小
        cfg.setBuffer(8 * 1024);
        // CPU + 1 ,性能调优# IO线程池，接收网络读写中断，以及序列化和反序列化，不处理业务，业务线程池参见threads配置，此线程池和CPU相关，不建议配置。
        cfg.setIothreads(8);
        // 服务治理# 所支持的telnet命令，多个命令用逗号分隔
        cfg.setTelnet("");
        // 服务治理# 缺省为空串
        cfg.setContextpath("");
        // 服务治理 #服务提供者所在的分层。如：biz、dao、intl
        cfg.setLayer("dao");
    }

    /**
     * 协议配置 :用于配置提供服务的协议信息，协议由提供方指定，消费方被动接受。
     * 
     * 同时，如果需要支持多协议，可以声明多个 <dubbo:protocol> 标签，并在 <dubbo:service> 中通过 protocol 属性指定使用的协议。
     */
    public void protocolConfig() {
        ProtocolConfig cfg = new ProtocolConfig();
        // 配置关联# 协议BeanId，可以在<dubbo:service protocol="">中引用此ID，如果ID不填，缺省和name属性值一样，重复则在name后加序号。
        cfg.setId("dubbo");
        // 性能调优# 协议名称
        cfg.setName("dubbo");
        /*
         * dubbo协议缺省端口为20880，rmi协议缺省端口为1099，http和hessian协议缺省端口为80；如果没有配置port，则自动采用默认端口，如果配置为-1，则会分配一个没有被占用的端口。
         * Dubbo分配的端口在协议缺省端口的基础上增长，确保端口段可控。 服务发现# 服务端口
         */
        cfg.setPort(-1);
        // 自动查找本机IP 。 服务发现# -服务主机名，多网卡选择或指定VIP及域名时使用，为空则自动查找本机IP，-建议不要配置，让Dubbo自动获取本机IP
        cfg.setHost(null);
        // 性能调优# 线程池类型，可选：fixed/cached
        cfg.setThreadpool("fixed");
        // 性能调优# 服务线程池大小(固定大小)
        cfg.setThreads(200);
        // cpu个数+1。 性能调优# io线程池大小(固定大小)
        cfg.setIothreads(null);
        // 性能调优# 服务提供方最大可接受连接数
        cfg.setAccepts(0);
        // 8388608(=8M) 性能调优# 请求及响应数据包大小限制，单位：字节
        cfg.setPayload(8 * 1024 * 1024);
        // 性能调优# 协议编码方式
        cfg.setCodec("dubbo");
        /*
         * dubbo协议缺省为hessian2，rmi协议缺省为java，http协议缺省为json 。 性能调优#
         * 协议序列化方式，当协议支持多种序列化方式时使用，比如：dubbo协议的dubbo,hessian2,java,compactedjava，以及http协议的json等
         */
        cfg.setSerialization("hessian2");
        //   服务治理# 设为true，将向logger中输出访问日志，也可填写访问日志文件路径，直接把访问日志输出到指定文件
        cfg.setAccesslog(null);
        // 服务发现# 提供者上下文路径，为服务path的前缀
        cfg.setPath("");
        // dubbo协议缺省为netty 性能调优# 协议的服务端和客户端实现类型，比如：dubbo协议的mina,netty等，可以分拆为server和client配置
        cfg.setTransporter("netty");
        // dubbo协议缺省为netty，http协议缺省为servlet 性能调优# 协议的服务器端实现类型，比如：dubbo协议的mina,netty等，http协议的jetty,servlet等
        cfg.setServer("netty");
        // dubbo协议缺省为netty 。性能调优# 协议的客户端实现类型，比如：dubbo协议的mina,netty等
        cfg.setClient("netty");
        // dubbo协议缺省为all 性能调优# 协议的消息派发方式，用于指定线程模型，比如：dubbo协议的all, direct, message, execution, connection等
        cfg.setDispatcher("all");
        // 性能调优# 线程池队列大小，当线程池满时，排队等待执行的队列大小，建议不要设置，当线程程池时应立即失败，重试其它服务提供机器，而不是排队，除非有特殊需求。
        cfg.setQueues(0);
        // 性能调优# 序列化编码
        cfg.setCharset("UTF-8");
        // 性能调优# 网络读写缓冲区大小
        cfg.setBuffer(8192);
        // 性能调优# 心跳间隔，对于长连接，当物理层断开时，比如拔网线，TCP的FIN消息来不及发送，对方收不到断开事件，此时需要心跳来帮助检查连接是否已断开
        cfg.setHeartbeat(0);
        //   服务治理# 所支持的telnet命令，多个命令用逗号分隔
        cfg.setTelnet(null);
        // 服务治理# 该协议的服务是否注册到注册中心
        cfg.setRegister(true);
        // 缺省为空串 服务治理#  
        cfg.setContextpath("");
        /*
         * 选项参数配置。dubbo:parameter同时该标签为<dubbo:protocol>或<dubbo:service>或<dubbo:provider>或<dubbo:reference>
         * 或<dubbo:consumer>的子标签， 用于配置自定义参数，该配置项将作为扩展点设置自定义参数使用。
         */
        cfg.setParameters(new HashMap<>());

    }

    /**
     * 服务配置 :用于暴露一个服务，定义服务的元信息，一个服务可以用多个协议暴露，一个服务也可以注册到多个注册中心。
     * 
     */
    public void serviceConfig() {
        ServiceConfig cfg = new ServiceConfig();
        // 服务发现:服务接口名
        cfg.setInterface(FacadeDemo.class);
        // 服务发现:服务对象实现引用
        cfg.setRef(new FacadeDemoService());
        // 服务发现:服务版本，建议使用两位数字版本，如：1.0，通常在接口不兼容时版本号才需要升级
        cfg.setVersion("1.0");
        // 可选, 服务发现, 服务分组，当一个接口有多个实现，可以用分组区分
        cfg.setGroup("");
        // 可选, 缺省为接口名 ,服务发现 : 服务路径 (注意：1.0不支持自定义路径，总是使用接口名，如果有1.0调2.0，配置服务路径可能不兼容)
        cfg.setPath("");
        // 性能调优: 延迟注册服务时间(毫秒) ，设为-1时，表示延迟到Spring容器初始化完成时暴露服务
        cfg.setDelay(-1);
        // 性能调优: 远程服务调用超时时间(毫秒)
        cfg.setTimeout(1000);
        // 性能调优： 远程服务调用重试次数，不包括第一次调用，不需要重试请设为0
        cfg.setRetries(2);
        // 性能调优 : 对每个提供者的最大连接数，rmi、http、hessian等短连接协议表示限制连接数，dubbo等长连接协表示建立的长连接个数
        cfg.setConnections(100);
        // 性能调优: 负载均衡策略，可选值：random,roundrobin,leastactive，分别表示：随机，轮循，最少活跃调用
        cfg.setLoadbalance("random");
        // 性能调优: 是否缺省异步执行，不可靠异步，只是忽略返回值，不阻塞执行线程
        cfg.setAsync(false);
        /*
         * 服务治理 : 设为true，表示使用缺省代理类名，即：接口名 + Local后缀，服务接口客户端本地代理类名，用于在客户端执行本地逻辑，如本地缓存等，
         * 该本地代理类的构造函数必须允许传入远程代理对象，构造函数如：public XxxServiceLocal(XxxService xxxService)
         */
        cfg.setStub(false);
        /*
         * 服务治理: 设为true，表示使用缺省Mock类名，即：接口名 + Mock后缀，服务接口调用失败Mock实现类，该Mock类必须有一个无参构造函数，与Local的区别在于，Local总是被执行，
         * 而Mock只在出现非业务异常(比如超时，网络异常等)时执行，Local在远程调用之前执行，Mock在远程调用后执行。
         */
        cfg.setMock(false);
        /* 服务治理 : 令牌验证，为空表示不开启，如果为true，表示随机生成动态令牌，否则使用静态令牌，令牌的作用是防止消费者绕过注册中心直接访问，保证注册中心的授权功能有效，如果使用点对点调用，需关闭令牌功能 */
        cfg.setToken(false);
        // 缺省向所有registry注册 ,配置关联:
        // 向指定注册中心注册，在多个注册中心时使用，值为<dubbo:registry>的id属性，多个注册中心ID用逗号分隔，如果不想将该服务注册到任何registry，可将值设为N/A
        cfg.setRegistry(null);
        // 缺使用第一个provider配置 , 配置关联: 指定provider，值为<dubbo:provider>的id属性
        cfg.setProvider(null);
        // 服务治理 : 服务是否过时，如果设为true，消费方引用时将打印服务过时警告error日志
        cfg.setDeprecated(false);
        // 服务治理: 服务是否动态注册，如果设为false，注册后将显示后disable状态，需人工启用，并且服务提供者停止时，也不会自动取消册，需人工禁用。
        cfg.setDynamic(true);
        // 服务治理: 设为true，将向logger中输出访问日志，也可填写访问日志文件路径，直接把访问日志输出到指定文件
        cfg.setAccesslog(false);
        // 服务治理: 服务负责人，用于服务治理，请填写负责人公司邮箱前缀
        cfg.setOwner("hanjy");
        // 服务治理: 服务文档URL
        cfg.setDocument(null);
        // 性能调优: 服务权重
        cfg.setWeight(5);
        // 性能调优: 服务提供者每服务每方法最大可并行执行请求数
        cfg.setExecutes(0);
        // 性能调优: 生成动态代理方式，可选：jdk/javassist
        cfg.setProxy("javassist");
        /**
         * 性能调优 : 集群方式，可选：failover/failfast/failsafe/failback/forking
         * <li>Failover Cluster 失败自动切换，当出现失败，重试其它服务器。通常用于读操作，但重试会带来更长延迟。可通过 retries="2" 来设置重试次数(不含第一次)。
         * <li>Failfast Cluster: 快速失败，只发起一次调用，失败立即报错。通常用于非幂等性的写操作，比如新增记录。
         * <li>Failsafe Cluster 失败安全，出现异常时，直接忽略。通常用于写入审计日志等操作。
         * <li>Failback Cluster 失败自动恢复，后台记录失败请求，定时重发。通常用于消息通知操作。
         * <li>Forking Cluster 并行调用多个服务器，只要一个成功即返回。通常用于实时性要求较高的读操作，但需要浪费更多服务资源。可通过 forks="2" 来设置最大并行数。
         * <li>Broadcast Cluster 广播调用所有提供者，逐个调用，任意一台报错则报错。通常用于通知所有提供者更新缓存或日志等本地资源信息。
         */
        cfg.setCluster("failover");
        // 性能调优: 服务提供方远程调用过程拦截器名称，多个名称用逗号分隔
        cfg.setFilter("default");
        // 性能调优: 服务提供方导出服务监听器名称，多个名称用逗号分隔  
        cfg.setListener("default");
        // 配置关联: 使用指定的协议暴露服务，在多协议时使用，值为<dubbo:protocol>的id属性，多个协议ID用逗号分隔
        cfg.setProtocol(null);
        // 服务治理: 服务提供者所在的分层。如：biz、dao、intl:web、china:acton。
        cfg.setLayer("dao");
        // 服务治理 :该协议的服务是否注册到注册中心
        cfg.setRegister(true);
    }
}
